import { NextRequest, NextResponse } from 'next/server'
import { getAccessToken, getCasdoorUser } from '@/lib/casdoor'
import { userQueries } from '@/lib/database-prisma'
import { assignUserColor } from '@/lib/colors'

// 简单的内存缓存来防止重复处理同一个授权码
const processedCodes = new Set<string>()

export async function GET(request: NextRequest) {
  // 立即输出日志，确保函数被调用
  console.log('🚀 回调函数被调用了！')
  console.log('🚀 当前时间:', new Date().toISOString())
  
  const { searchParams } = new URL(request.url)
  const code = searchParams.get('code')
  const state = searchParams.get('state')
  const error = searchParams.get('error')

  console.log('=== 认证回调开始 ===')
  console.log('Code:', code)
  console.log('State:', state)
  console.log('Error:', error)
  console.log('Request URL:', request.url)

  // 检查是否有错误
  if (error) {
    console.error('Casdoor认证错误:', error)
    return NextResponse.redirect(`${process.env.NEXTAUTH_URL}/?error=auth_failed`)
  }

  // 检查是否有授权码
  if (!code) {
    console.error('缺少授权码')
    return NextResponse.redirect(`${process.env.NEXTAUTH_URL}/?error=missing_code`)
  }

  // 检查授权码是否已经被处理过
  if (processedCodes.has(code)) {
    console.log('授权码已经被处理过，忽略重复请求')
    return NextResponse.redirect(`${process.env.NEXTAUTH_URL}/`)
  }

  // 标记授权码为已处理
  processedCodes.add(code)

  try {
    // 获取访问令牌
    const redirectUri = `${process.env.NEXTAUTH_URL}/api/auth/callback`
    console.log('获取访问令牌，重定向URI:', redirectUri)
    
    const accessToken = await getAccessToken(code, redirectUri)
    console.log('访问令牌获取成功:', accessToken ? '是' : '否')

    // 获取用户信息
    console.log('获取用户信息...')
    const casdoorUser = await getCasdoorUser(accessToken)
    console.log('Casdoor用户信息:', {
      id: casdoorUser.id,
      name: casdoorUser.name,
      displayName: casdoorUser.displayName,
      email: casdoorUser.email
    })

    // 首先根据Casdoor ID查找用户
    let user: any = await userQueries.findByCasdoorId.get(casdoorUser.id)
    console.log('根据Casdoor ID查找用户:', user ? '找到' : '未找到')

    if (!user) {
      // 如果根据Casdoor ID没找到，再根据用户名查找
      const existingUserByName = await userQueries.findByName.get(casdoorUser.displayName || casdoorUser.name)
      console.log('根据用户名查找现有用户:', existingUserByName ? '找到' : '未找到')

      if (existingUserByName) {
        // 如果用户名已存在，更新该用户的Casdoor ID
        console.log('用户名已存在，更新Casdoor ID...')
        try {
          // 更新现有用户的Casdoor ID
          const updateResult = await userQueries.updateCasdoorId.run(casdoorUser.id, (existingUserByName as any).id)
          console.log('更新Casdoor ID结果:', updateResult)
          
          // 重新获取用户信息
          user = await userQueries.findById.get((existingUserByName as any).id)
          console.log('更新后的用户:', user)
        } catch (updateError) {
          console.error('更新Casdoor ID失败:', updateError)
          // 如果更新失败，使用现有用户
          user = existingUserByName
        }
      } else {
        // 创建新用户，先尝试使用原始用户名
        const originalUserName = casdoorUser.displayName || casdoorUser.name
        let userName = originalUserName
        
        // 检查用户名是否已存在，如果存在则添加时间戳
        const existingUser = await userQueries.findByName.get(userName)
        if (existingUser) {
          userName = `${originalUserName}_${Date.now()}`
          console.log('用户名冲突，使用唯一用户名:', userName)
        } else {
          console.log('使用原始用户名:', userName)
        }
        
        const userColor = await assignUserColor() // 分配唯一颜色
        
        console.log('创建新用户，用户名:', userName)
        console.log('分配颜色:', userColor)
        try {
          const result = await userQueries.create.run(
            userName,
            userColor, // 使用分配的颜色
            casdoorUser.id,
            casdoorUser.email,
            casdoorUser.avatar || ''
          )
          console.log('创建用户结果:', result)
          
          // 获取新创建的用户信息
          user = await userQueries.findById.get(result.lastInsertRowid as number)
          console.log('新创建的用户:', user)
        } catch (createError) {
          console.error('创建用户失败:', createError)
          return NextResponse.redirect(`${process.env.NEXTAUTH_URL}/?error=create_user_failed`)
        }
      }
    } else {
      // 用户已存在，更新用户信息（保持颜色不变）
      console.log('用户已存在，更新用户信息...')
      try {
        await userQueries.update.run(
          casdoorUser.displayName || casdoorUser.name,
          casdoorUser.email,
          casdoorUser.avatar || '',
          casdoorUser.id
        )
        console.log('用户信息更新成功')
        
        // 重新获取更新后的用户信息
        user = await userQueries.findById.get(user.id)
      } catch (updateError) {
        console.error('更新用户信息失败:', updateError)
        // 继续使用现有用户信息
      }
    }

    console.log('最终用户信息:', user)

    // 设置cookies并重定向到dashboard
    const response = NextResponse.redirect(`${process.env.NEXTAUTH_URL}/dashboard`)
    
    // 设置用户ID cookie
    response.cookies.set('user_id', user.id.toString(), {
      httpOnly: true,
      secure: process.env.NODE_ENV === 'production' && process.env.NEXTAUTH_URL?.startsWith('https'),
      sameSite: 'lax',
      maxAge: 60 * 60 * 24 * 7, // 7天
      path: '/'
    })
    
    // 设置访问令牌cookie
    response.cookies.set('access_token', accessToken, {
      httpOnly: true,
      secure: process.env.NODE_ENV === 'production' && process.env.NEXTAUTH_URL?.startsWith('https'),
      sameSite: 'lax',
      maxAge: 60 * 60 * 24 * 7, // 7天
      path: '/'
    })
    
    console.log('认证成功，重定向到dashboard')
    console.log('=== 认证回调结束 ===')
    
    // 成功处理后清理缓存中的授权码
    processedCodes.delete(code)
    
    return response
  } catch (error) {
    console.error('认证回调过程中发生错误:', error)
    // 错误处理后清理缓存中的授权码
    processedCodes.delete(code)
    return NextResponse.redirect(`${process.env.NEXTAUTH_URL}/?error=auth_error`)
  }
}

// 定期清理缓存，防止内存泄漏（每5分钟清理一次）
setInterval(() => {
  if (processedCodes.size > 0) {
    console.log('清理授权码缓存，当前大小:', processedCodes.size)
    processedCodes.clear()
  }
}, 5 * 60 * 1000)